// 栈数据结构使用示例
const 栈 = require('../../zh/公共函数/zh-stack.js').栈;

/**
 * 基本操作示例
 */
console.log('=== 基本操作示例 ===');
const 数字栈 = new 栈([1, 2, 3]);
console.log('初始栈:', 数字栈.取值());

// 入栈操作
数字栈.入栈(4);
console.log('入栈后:', 数字栈.取值());

// 出栈操作
const 出栈元素 = 数字栈.出栈();
console.log('出栈元素:', 出栈元素);
console.log('出栈后:', 数字栈.取值());

// 查看栈顶元素
console.log('栈顶元素:', 数字栈.查看栈顶());

// 栈大小
console.log('栈大小:', 数字栈.大小());

// 判断是否为空
console.log('是否为空:', 数字栈.是否为空());

/**
 * 多次入栈出栈示例
 */
console.log('\n=== 多次入栈出栈示例 ===');
const 操作栈 = new 栈();
操作栈.入栈('a');
操作栈.入栈('b');
操作栈.入栈('c');
console.log('多次入栈后:', 操作栈.取值());

操作栈.出栈();
console.log('出栈一次后:', 操作栈.取值());
操作栈.出栈();
console.log('出栈两次后:', 操作栈.取值());

/**
 * 字符串处理示例
 */
console.log('\n=== 字符串处理示例 ===');
const 字符串栈 = new 栈(['h', 'e', 'l', 'l', 'o']);

// 模拟字符串反转
const 反转结果 = [];
while (!字符串栈.是否为空()) {
  反转结果.push(字符串栈.出栈());
}
console.log('字符串反转结果:', 反转结果.join(''));

/**
 * 括号匹配示例
 */
console.log('\n=== 括号匹配示例 ===');
function 括号匹配(字符串) {
  const 括号栈 = new 栈();
  const 匹配映射 = { ']': '[', '}': '{', ')': '(' };
  
  for (let i = 0; i < 字符串.length; i++) {
    const 字符 = 字符串[i];
    if (['[', '{', '('].includes(字符)) {
      括号栈.入栈(字符);
    } else if (匹配映射[字符]) {
      if (括号栈.是否为空() || 括号栈.出栈() !== 匹配映射[字符]) {
        return false;
      }
    }
  }
  
  return 括号栈.是否为空();
}

const 测试用例 = ['()', '()[]{}', '(]', '([)]', '{[]}'];
测试用例.forEach(test => {
  console.log(`"${test}" 匹配:`, 括号匹配(test));
});

/**
 * 数字进制转换示例
 */
console.log('\n=== 数字进制转换示例 ===');
function 十进制转二进制(十进制数) {
  const 结果栈 = new 栈();
  let 商 = 十进制数;
  
  if (商 === 0) return '0';
  
  while (商 > 0) {
    结果栈.入栈(商 % 2);
    商 = Math.floor(商 / 2);
  }
  
  let 二进制结果 = '';
  while (!结果栈.是否为空()) {
    二进制结果 += 结果栈.出栈();
  }
  
  return 二进制结果;
}

console.log('10 转二进制:', 十进制转二进制(10));
console.log('42 转二进制:', 十进制转二进制(42));
console.log('0 转二进制:', 十进制转二进制(0));

/**
 * 浏览器历史记录简单模拟
 */
console.log('\n=== 浏览器历史记录模拟 ===');
class 简单浏览器历史 {
  constructor() {
    this.后退栈 = new 栈();
    this.前进栈 = new 栈();
    this.当前页 = null;
  }
  
  访问(url) {
    if (this.当前页) {
      this.后退栈.入栈(this.当前页);
    }
    this.当前页 = url;
    // 清空前进栈
    while (!this.前进栈.是否为空()) {
      this.前进栈.出栈();
    }
    console.log(`访问: ${url}`);
  }
  
  后退() {
    if (this.后退栈.是否为空()) {
      console.log('无法后退');
      return;
    }
    this.前进栈.入栈(this.当前页);
    this.当前页 = this.后退栈.出栈();
    console.log(`后退到: ${this.当前页}`);
  }
  
  前进() {
    if (this.前进栈.是否为空()) {
      console.log('无法前进');
      return;
    }
    this.后退栈.入栈(this.当前页);
    this.当前页 = this.前进栈.出栈();
    console.log(`前进到: ${this.当前页}`);
  }
  
  显示状态() {
    console.log(`\n浏览器状态:`);
    console.log(`当前页: ${this.当前页}`);
    console.log(`后退历史: [${this.后退栈.取值().join(', ')}]`);
    console.log(`前进历史: [${this.前进栈.取值().join(', ')}]`);
  }
}

const 浏览器 = new 简单浏览器历史();
浏览器.访问('首页');
浏览器.访问('新闻页');
浏览器.访问('视频页');
浏览器.显示状态();
浏览器.后退();
浏览器.显示状态();
浏览器.前进();
浏览器.访问('设置页');
浏览器.显示状态();

console.log('\n=== 栈数据结构基础使用示例完成 ===');
